home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / modula2 / hk_lib / def_mod / memory.def < prev    next >
Encoding:
Modula Definition  |  1994-09-22  |  5.7 KB  |  104 lines
  1. DEFINITION MODULE  MEMORY;
  2.  
  3. (*****************************************************************************)
  4. (* Die in diesem Modul enthaltenen Prozeduren dienen der direkten Manipula-  *)
  5. (* tion groesserer Speicherbereiche. Vor allem solcher, deren Groesse erst   *)
  6. (* zur Laufzeit feststeht ( z.B. offene ARRAY-Parameter ). Die Anfangsadres- *)
  7. (* sen der Speicherbereiche koennen sowohl gerade als auch ungerade sein.    *)
  8. (* Wenn allerdings bei einer Prozedur, die zwei Speicherbereiche benoetigt,  *)
  9. (* der eine an ungerader, der andere an gerader Adresse beginnt, sinkt die   *)
  10. (* Geschwindigkeit deutlich ab - die Routinen brauchen mehr als doppelt so   *)
  11. (* lang ( es wird nur byteweise kopiert, sonst langwortweise ).              *)
  12. (*___________________________________________________________________________*)
  13. (*  07-Feb-90 , Holger Kleinschmidt                                          *)
  14. (*****************************************************************************)
  15.  
  16. FROM  SYSTEM  IMPORT (* TYPE *)  ADDRESS;
  17.  
  18. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  19.  
  20. TYPE  CopyProc = PROCEDURE ((* EIN  quelle *) ADDRESS,
  21.                             (* EIN  ziel   *) ADDRESS,
  22.                             (* EIN  laenge *) CARDINAL );
  23.  
  24. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  25.  
  26. PROCEDURE  ClearMem ((* EIN/ -- *)  start  : ADDRESS;
  27.                      (* EIN/ -- *)  laenge : CARDINAL );
  28.  
  29. (*--------------------------------------------------------------------------
  30.  | Diese Prozedur ueberschreibt einen Speicherbereich von <laenge> Bytes    |
  31.  | beginnend bei Adresse <start> mit Nullbytes.                             |
  32.  |  - Ist <laenge> = Null, passiert nichts                                  |
  33.   --------------------------------------------------------------------------*)
  34.  
  35.  
  36. PROCEDURE  FillMem ((* EIN/ -- *)  start  : ADDRESS;
  37.                     (* EIN/ -- *)  laenge : CARDINAL;
  38.                     (* EIN/ -- *)  muster : LONGCARD );
  39.  
  40. (*--------------------------------------------------------------------------
  41.  | Diese Prozedur fuellt einen Speicherbereich von <laenge> Bytes beginnend |
  42.  | bei Adresse <start> mit dem <muster>. Da <muster> ein  LONGCARD-Wert ist,|
  43.  | lassen sich Muster bis zu einer Laenge von vier Bytes benutzen. Soll das |
  44.  | Muster alle zwei Bytes wiederholt werden, so uebergibt man eben als      |
  45.  | <muster> das Muster zweimal hintereinander, soll das Muster nur ein Byte |
  46.  | Laenge haben, so uebergibt man vier gleiche Bytes hintereinander.        |
  47.  |                                                                          |
  48.  | Beispiel: 4-Byte-Muster  <muster>   = 0FEDCBA98H                         |
  49.  |           2-Byte-Muster     "       =  12341234H                         |
  50.  |           1-Byte-Muster     "       =  5A5A5A5AH                         |
  51.  |                                                                          |
  52.  | Ein 2- oder 4-Byte-Muster kann auch an einer ungeraden Adr. beginnen !   |
  53.  |  - Ist <laenge> = Null, passiert nichts                                  |
  54.   --------------------------------------------------------------------------*)
  55.  
  56.  
  57. PROCEDURE  CopyMem ((* EIN/ -- *)  quelle,
  58.                     (* EIN/ -- *)  ziel   : ADDRESS;
  59.                     (* EIN/ -- *)  laenge : CARDINAL );
  60.  
  61. (*--------------------------------------------------------------------------
  62.  | Die Prozedur kopiert <laenge> Bytes des Speicherbereiches ab der Adresse |
  63.  | <quelle> in den Speicherbereich ab der Adresse <ziel>. Die Speicherbe-   |
  64.  | reiche duerfen sich ueberlappen.                                         |
  65.  |  - Ist <laenge> = Null, passiert nichts                                  |
  66.   --------------------------------------------------------------------------*)
  67.  
  68. PROCEDURE  CopySmallMem ((* EIN/ -- *)  quelle,
  69.                          (* EIN/ -- *)  ziel   : ADDRESS;
  70.                          (* EIN/ -- *)  laenge : CARDINAL );
  71.  
  72. (*--------------------------------------------------------------------------
  73.  | Dies ist eine schnelle Variante von "CopyMem" fuer 'kleine' Speicherbe-  |
  74.  | reiche ( ~ bis 10 Bytes ). Die Speicherbereiche duerfen sich NICHT ueber-|
  75.  | lappen. Diese Routine kann man also benutzen, wenn wahrscheinlich ist,   |
  76.  | dass nur Standardtypen kopiert werden, aber kein bestimmter festliegt.   |
  77.   --------------------------------------------------------------------------*)
  78.  
  79.  
  80. PROCEDURE  SwapMem ((* EIN/ -- *)  block1,
  81.                     (* EIN/ -- *)  block2 : ADDRESS;
  82.                     (* EIN/ -- *)  laenge : CARDINAL );
  83.  
  84. (*--------------------------------------------------------------------------
  85.  | Die Prozedur tauscht <laenge> Bytes der beiden Speicherbereiche ab den   |
  86.  | Adressen <block1> und <block2> gegeneinander aus.                        |
  87.  | Diese Prozedur wird z.B. von Sortierroutinen benoetigt.                  |
  88.  |  - Ist <laenge> = Null, passiert nichts                                  |
  89.   --------------------------------------------------------------------------*)
  90.  
  91.  
  92. PROCEDURE  EqualMem ((* EIN/ -- *)  block1,
  93.                      (* EIN/ -- *)  block2 : ADDRESS;
  94.                      (* EIN/ -- *)  laenge : CARDINAL ): BOOLEAN;
  95.  
  96. (*--------------------------------------------------------------------------
  97.  | Die Funktion vergleicht <laenge> Bytes der beiden Speicherbereiche ab den|
  98.  | Adressen <block1> und <block2> miteinander. Sind alle Bytes der beiden   |
  99.  | Bloecke gleich, wird TRUE zurueckgeliefert, sonst FALSE                  |
  100.  |  - Ist <laenge> = Null, wird TRUE zurueckgeliefert                       |
  101.   --------------------------------------------------------------------------*)
  102.  
  103. END  MEMORY.
  104.